package com.starhub.engine.ai.biz;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * AI函数实现类
 * 提供一些示例函数实现，用于演示函数调用功能
 */
@Slf4j
@Component
public class AiFunctionImplementation {

    /**
     * 获取城市天气预报
     *
     * @param city 城市名称
     * @param days 天数，默认为1
     * @return 天气预报信息
     */
    public Map<String, Object> getWeather(String city, Integer days) {
        log.info("获取{}的{}天天气预报", city, days);

        // 如果days为null，使用默认值1
        int forecastDays = (days != null) ? days : 1;

        // 检查参数有效性
        if (forecastDays < 1) {
            forecastDays = 1;
        } else if (forecastDays > 7) {
            forecastDays = 7; // 限制最大天数为7天
        }

        // 模拟天气数据，实际应用中会调用天气API
        Map<String, Object> result = new HashMap<>();
        result.put("city", city);
        result.put("days", forecastDays);

        List<Map<String, Object>> forecast = new ArrayList<>();

        // 模拟天气类型
        String[] weatherTypes = { "晴朗", "多云", "阴天", "小雨", "中雨", "大雨", "雷阵雨", "小雪", "大雪" };
        // 模拟各城市温度基准
        Map<String, Integer> baseTemperatures = new HashMap<>();
        baseTemperatures.put("北京", 25);
        baseTemperatures.put("上海", 28);
        baseTemperatures.put("广州", 30);
        baseTemperatures.put("深圳", 29);
        baseTemperatures.put("成都", 26);
        baseTemperatures.put("杭州", 27);

        // 获取基准温度，默认为25度
        int baseTemp = baseTemperatures.getOrDefault(city, 25);

        // 生成预报数据
        for (int i = 0; i < forecastDays; i++) {
            Map<String, Object> dayForecast = new HashMap<>();

            // 模拟日期（今天+i天）
            dayForecast.put("date", "2023-06-" + String.format("%02d", 20 + i));

            // 模拟天气类型（随机选择）
            String weatherType = weatherTypes[(int) (Math.random() * weatherTypes.length)];
            dayForecast.put("weather", weatherType);

            // 模拟温度（基于基准温度随机波动）
            int tempVariation = (int) (Math.random() * 6) - 3; // -3到+3的随机波动
            int temperature = baseTemp + tempVariation;
            dayForecast.put("temperature", temperature);

            // 模拟温度范围
            dayForecast.put("minTemperature", temperature - 5);
            dayForecast.put("maxTemperature", temperature + 5);

            // 模拟湿度
            dayForecast.put("humidity", (int) (Math.random() * 50) + 30); // 30-80%

            // 模拟风力
            dayForecast.put("windForce", (int) (Math.random() * 6) + 1); // 1-6级

            forecast.add(dayForecast);
        }

        result.put("forecast", forecast);
        return result;
    }

    /**
     * 计算器函数
     *
     * @param num1
     * @param num2
     * @param operation 运算类型，可选值：add, subtract, multiply, divide
     * @return 计算结果
     */
    public String calculate(Double num1, Double num2, String operation) {
        try {
            // 简单实现，仅支持基本加减乘除
            // 实际应用中应使用专业的表达式解析库
            String expression = num1 + operation + num2;
            String result = String.valueOf(eval(expression));
            return expression + " = " + result;
        } catch (Exception e) {
            return "计算错误: " + e.getMessage();
        }
    }

    // 简单的表达式求值方法（只处理简单的加减乘除）
    private double eval(final String str) {
        return new Object() {
            int pos = -1, ch;

            void nextChar() {
                ch = (++pos < str.length()) ? str.charAt(pos) : -1;
            }

            boolean eat(int charToEat) {
                while (ch == ' ')
                    nextChar();
                if (ch == charToEat) {
                    nextChar();
                    return true;
                }
                return false;
            }

            double parse() {
                nextChar();
                double x = parseExpression();
                if (pos < str.length())
                    throw new RuntimeException("意外字符: " + (char) ch);
                return x;
            }

            double parseExpression() {
                double x = parseTerm();
                for (;;) {
                    if (eat('+'))
                        x += parseTerm(); // 加法
                    else if (eat('-'))
                        x -= parseTerm(); // 减法
                    else
                        return x;
                }
            }

            double parseTerm() {
                double x = parseFactor();
                for (;;) {
                    if (eat('*'))
                        x *= parseFactor(); // 乘法
                    else if (eat('/'))
                        x /= parseFactor(); // 除法
                    else
                        return x;
                }
            }

            double parseFactor() {
                if (eat('+'))
                    return parseFactor(); // 正号
                if (eat('-'))
                    return -parseFactor(); // 负号

                double x;
                int startPos = this.pos;
                if (eat('(')) { // 括号
                    x = parseExpression();
                    eat(')');
                } else if ((ch >= '0' && ch <= '9') || ch == '.') { // 数字
                    while ((ch >= '0' && ch <= '9') || ch == '.')
                        nextChar();
                    x = Double.parseDouble(str.substring(startPos, this.pos));
                } else {
                    throw new RuntimeException("意外字符: " + (char) ch);
                }

                return x;
            }
        }.parse();
    }

    /**
     * 获取城市信息
     * 
     * @param cityName 城市名称
     * @return 城市信息
     */
    public Map<String, Object> getCityInfo(String cityName) {
        log.info("获取城市{}的信息", cityName);

        // 模拟城市信息数据库
        Map<String, Map<String, Object>> citiesDatabase = new HashMap<>();

        // 北京
        Map<String, Object> beijing = new HashMap<>();
        beijing.put("name", "北京");
        beijing.put("population", 21893000);
        beijing.put("area", 16410.54);
        beijing.put("province", "北京市");
        beijing.put("capital", true);
        citiesDatabase.put("北京", beijing);

        // 上海
        Map<String, Object> shanghai = new HashMap<>();
        shanghai.put("name", "上海");
        shanghai.put("population", 24870895);
        shanghai.put("area", 6340.5);
        shanghai.put("province", "上海市");
        shanghai.put("capital", false);
        citiesDatabase.put("上海", shanghai);

        // 广州
        Map<String, Object> guangzhou = new HashMap<>();
        guangzhou.put("name", "广州");
        guangzhou.put("population", 18676605);
        guangzhou.put("area", 7434.4);
        guangzhou.put("province", "广东省");
        guangzhou.put("capital", false);
        citiesDatabase.put("广州", guangzhou);

        if (citiesDatabase.containsKey(cityName)) {
            return citiesDatabase.get(cityName);
        } else {
            Map<String, Object> notFound = new HashMap<>();
            notFound.put("error", "未找到该城市信息");
            return notFound;
        }
    }

    /**
     * 搜索相关内容
     * 
     * @param keyword 关键词
     * @param limit   返回结果数量限制，默认为5
     * @return 搜索结果列表
     */
//    public List<Map<String, String>> search(String keyword, Integer limit) {
//        log.info("搜索关键词：{}，返回{}条结果", keyword, limit);
//
//        // 模拟搜索结果
//        List<Map<String, String>> results = new ArrayList<>();
//
//        // 添加一些模拟的搜索结果
//        for (int i = 0; i < limit; i++) {
//            Map<String, String> result = new HashMap<>();
//            result.put("title", "搜索结果 " + (i + 1) + ": 关于" + keyword + "的内容");
//            result.put("url", "https://example.com/search/" + keyword + "/" + i);
//            result.put("description", "这是关于" + keyword + "的第" + (i + 1) + "条详细描述信息。");
//            results.add(result);
//        }
//
//        return results;
//    }
}